package com.kehutong.common;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.Period;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.WeekFields;
import java.util.*;

import com.kehutong.common.util.DateUtil;
import org.coraframework.converter.util.StringUtil;
import org.coraframework.util.Objects;

public class DailyUtil {


	// private static final ZoneId zoneId = ZoneId.of("Asia/Shanghai");
	public static final ZoneId zoneId = ZoneId.systemDefault();

//	private static volatile int _nextZeroPoint = TimeUtil.getNextZeroPointSecond();
	private static volatile String _yyyy;
	private static volatile String _yyyyMM;
	private static volatile String _yyyyMMdd;
	private static volatile String _yyyy_MM;
	
	static {
		nextZeroPoint();
	}

	/**
	 * 日 开始时间
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay() {
		return startOfDay(LocalDate.now(), 0);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param date
	 *            日期 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(String date) {
		return startOfDay(LocalDate.parse(date), 0);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param date
	 *            日期 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(Date date) {
		return startOfDay(date2LocalDate(date), 0);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(LocalDate localDate) {
		return startOfDay(localDate, 0);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(int days) {
		return startOfDay(LocalDate.now(), days);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param date
	 *            日期 日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(String date, int days) {
		return startOfDay(LocalDate.parse(date), days);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param date
	 *            日期 日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(Date date, int days) {
		return startOfDay(date2LocalDate(date), days);
	}

	/**
	 * 日 开始时间
	 * 
	 * @param localDate
	 *            日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startOfDay(LocalDate localDate, int days) {
		if (days > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(days)
					.toInstant());
		}

		if (days < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusDays(Math.abs(days)).toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).toInstant());
	}
	
	/**
	 * 日 开始时间
	 * 
	 * @param days 间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static LocalDate toLocalDate(int days) {
		LocalDate localDate = LocalDate.now();
		if (days > 0) {
			return localDate.atStartOfDay(zoneId).plusDays(days).toLocalDate();
		}
		
		if (days < 0) {
			return localDate.atStartOfDay(zoneId).minusDays(Math.abs(days)).toLocalDate();
		}
		
		return localDate.atStartOfDay(zoneId).toLocalDate();
	}
	
	/**
	 * 日 开始时间
	 * 
	 * @param localDate 日期
	 * @param days 间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static LocalDate toLocalDate(LocalDate localDate, int days) {
		if (days > 0) {
			return localDate.atStartOfDay(zoneId).plusDays(days).toLocalDate();
		}

		if (days < 0) {
			return localDate.atStartOfDay(zoneId).minusDays(Math.abs(days)).toLocalDate();
		}

		return localDate.atStartOfDay(zoneId).toLocalDate();
	}

	/**
	 * 日 结束时间
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay() {
		return endOfDay(LocalDate.now(), 0);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(String date) {
		return endOfDay(LocalDate.parse(date), 0);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(Timestamp date) {
		return endOfDay(date2LocalDate(date), 0);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(LocalDate localDate) {
		return endOfDay(localDate, 0);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(int days) {
		return endOfDay(LocalDate.now(), days);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param date
	 *            日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(String date, int days) {
		return endOfDay(LocalDate.parse(date), days);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param date
	 *            日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(Timestamp date, int days) {
		return endOfDay(date2LocalDate(date), days);
	}

	/**
	 * 日 结束时间
	 * 
	 * @param localDate
	 *            日期
	 * @param days
	 *            间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endOfDay(LocalDate localDate, int days) {
		if (days > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(days + 1L)
					.minusSeconds(1L).toInstant());
		}

		if (days < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusDays(Math.abs(days) - 1L).minusSeconds(1L).toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(1L)
				.minusSeconds(1L).toInstant());
	}

	/**
	 * <pre>时间修改</pre>
	 * 
	 * @param date 日期
	 * @param hours 间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp timeOf(Timestamp date, int hours) {
		LocalDateTime dateTime = LocalDateTime
				.ofInstant(date.toInstant(), ZoneId.systemDefault());
		if (hours > 0) {
			dateTime = dateTime.plusHours(hours);
		}

		if (hours < 0) {
			dateTime = dateTime.minusHours(hours);
		}
		
		return Timestamp.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());
	}

	/**
	 * <pre>时间修改</pre>
	 * 
	 * @param localDate 日期
	 * @param hours 间隔日期 +以后日期 -以前日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp timeOf(LocalDate localDate, int hours) {
		if (hours > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.plusHours(hours).toInstant());
		}

		if (hours < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusHours(Math.abs(hours))
					.toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).toInstant());
	}
	
	/**
	 * 周 第一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfWeek() {
		return startDayOfWeek(LocalDate.now(), 0);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfWeek(String date) {
		return startDayOfWeek(LocalDate.parse(date), 0);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfWeek(Date date) {
		return startDayOfWeek(date2LocalDate(date), 0);
	}

	/**
	 * 周 第一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfWeek(LocalDate localDate) {
		return startDayOfWeek(localDate, 0);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date startDayOfWeek(long weeks) {
		return startDayOfWeek(LocalDate.now(), weeks);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date startDayOfWeek(String date, long weeks) {
		return startDayOfWeek(LocalDate.parse(date), weeks);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date startDayOfWeek(Date date, long weeks) {
		return startDayOfWeek(date2LocalDate(date), weeks);
	}

	/**
	 * 周 第一天
	 * 
	 * @param localDate
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Timestamp startDayOfWeek(LocalDate localDate, long weeks) {
		localDate = localDate.with(WeekFields.of(Locale.CHINA).dayOfWeek(), 1);
		if (weeks > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusWeeks(weeks)
					.toInstant());
		}

		if (weeks < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusWeeks(Math.abs(weeks)).toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).toInstant());
	}

	/**
	 * 周 第一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfWeek() {
		return endDayOfWeek(LocalDate.now(), 0);
	}

	/**
	 * 周 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfWeek(String date) {
		return endDayOfWeek(LocalDate.parse(date), 0);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfWeek(Date date) {
		return endDayOfWeek(date2LocalDate(date), 0);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfWeek(LocalDate localDate) {
		return endDayOfWeek(localDate, 0);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date endDayOfWeek(long weeks) {
		return endDayOfWeek(LocalDate.now(), weeks);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date endDayOfWeek(String date, long weeks) {
		return endDayOfWeek(LocalDate.parse(date), weeks);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param date
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Date endDayOfWeek(Date date, long weeks) {
		return endDayOfWeek(date2LocalDate(date), weeks);
	}

	/**
	 * 周 最后一天
	 * 
	 * @param localDate
	 *            指定日期
	 * @param weeks
	 *            间隔周 +以后周 -以前周
	 * @return 推延后日期
	 */
	public static Timestamp endDayOfWeek(LocalDate localDate, long weeks) {
		localDate = localDate.with(WeekFields.of(Locale.CHINA).dayOfWeek(), 7);

		if (weeks > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusWeeks(weeks)
					.plusDays(1).minusSeconds(1L).toInstant());
		}

		if (weeks < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusWeeks(Math.abs(weeks)).plusDays(1).minusSeconds(1L)
					.toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(1)
				.minusSeconds(1L).toInstant());
	}

	/**
	 * 月 第一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth() {
		return startDayOfMoth(LocalDate.now(), 0);
	}

	/**
	 * 月 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(String date) {
		return startDayOfMoth(LocalDate.parse(date), 0);
	}

	/**
	 * 月 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(Date date) {
		return startDayOfMoth(date2LocalDate(date), 0);
	}

	/**
	 * 月 第一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(LocalDate localDate) {
		return startDayOfMoth(localDate, 0);
	}

	/**
	 * 月 第一天
	 * 
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(int months) {
		return startDayOfMoth(LocalDate.now(), months);
	}

	/**
	 * 月 第一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(String date, int months) {
		return startDayOfMoth(LocalDate.parse(date), months);
	}

	/**
	 * 月 第一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(Date date, int months) {
		return startDayOfMoth(date2LocalDate(date), months);
	}

	/**
	 * 月 第一天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp startDayOfMoth(LocalDate localDate, int months) {
		localDate = localDate.with(TemporalAdjusters.firstDayOfMonth());
		if (months > 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusMonths(months)
					.toInstant());
		}

		if (months < 0) {
			return Timestamp.from(localDate.atStartOfDay(zoneId)
					.minusMonths(Math.abs(months)).toInstant());
		}

		return Timestamp.from(localDate.atStartOfDay(zoneId).toInstant());
	}

	/**
	 * 月 最后一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth() {
		return endDayOfMoth(LocalDate.now(), 0);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(String date) {
		return endDayOfMoth(LocalDate.parse(date), 0);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(Date date) {
		return endDayOfMoth(date2LocalDate(date), 0);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(LocalDate localDate) {
		return endDayOfMoth(localDate, 0);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(int months) {
		return endDayOfMoth(LocalDate.now(), months);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(String date, int months) {
		return endDayOfMoth(LocalDate.parse(date), months);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(Date date, int months) {
		return endDayOfMoth(date2LocalDate(date), months);
	}

	/**
	 * 月 最后一天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Timestamp endDayOfMoth(LocalDate localDate, int months) {

		if (months > 0) {
			localDate = localDate.plusMonths(months).with(
					TemporalAdjusters.lastDayOfMonth());
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(1)
					.minusSeconds(1).toInstant());
		}

		if (months < 0) {
			localDate = localDate.minusMonths(Math.abs(months)).with(
					TemporalAdjusters.lastDayOfMonth());
			return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(1)
					.minusSeconds(1).toInstant());
		}

		localDate = localDate.with(TemporalAdjusters.lastDayOfMonth());
		return Timestamp.from(localDate.atStartOfDay(zoneId).plusDays(1)
				.minusSeconds(1).toInstant());
	}

	/**
	 * 第N月的今天
	 * 
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfMoth(int months) {
		return dayOfMoth(LocalDate.now(), months);
	}

	/**
	 * 第N月的今天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfMoth(String date, int months) {
		return dayOfMoth(LocalDate.parse(date), months);
	}

	/**
	 * 第N月的今天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfMoth(Date date, int months) {
		return dayOfMoth(date2LocalDate(date), months);
	}

	/**
	 * 第N月的今天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔月 +以后月 -以前月
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfMoth(LocalDate localDate, int months) {
		if (months > 0) {
			return Date.from(localDate.atStartOfDay(zoneId).plusMonths(months)
					.toInstant());
		}

		if (months < 0) {
			return Date.from(localDate.atStartOfDay(zoneId)
					.minusMonths(Math.abs(months)).toInstant());
		}

		return new Date();
	}

	/**
	 * 年 第一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear() {
		return startDayOfYear(LocalDate.now(), 0);
	}

	/**
	 * 年 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(String date) {
		return startDayOfYear(LocalDate.parse(date), 0);
	}

	/**
	 * 年 第一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(Date date) {
		return startDayOfYear(date2LocalDate(date), 0);
	}

	/**
	 * 年 第一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(LocalDate localDate) {
		return startDayOfYear(localDate, 0);
	}

	/**
	 * 年 第一天
	 * 
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(int years) {
		return startDayOfYear(LocalDate.now(), years);
	}

	/**
	 * 年 第一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(String date, int years) {
		return startDayOfYear(LocalDate.parse(date), years);
	}

	/**
	 * 年 第一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(Date date, int years) {
		return startDayOfYear(date2LocalDate(date), years);
	}

	/**
	 * 年 第一天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date startDayOfYear(LocalDate localDate, int years) {
		localDate = localDate.with(TemporalAdjusters.firstDayOfYear());

		if (years > 0) {
			return Date.from(localDate.atStartOfDay(zoneId).plusYears(years)
					.toInstant());
		}

		if (years < 0) {
			return Date.from(localDate.atStartOfDay(zoneId)
					.minusYears(Math.abs(years)).toInstant());
		}

		return Date.from(localDate.atStartOfDay(zoneId).toInstant());
	}

	/**
	 * 年 最后一天
	 * 
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear() {
		return endDayOfYear(LocalDate.now(), 0);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(String date) {
		return endDayOfYear(LocalDate.parse(date), 0);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(Date date) {
		return endDayOfYear(date2LocalDate(date), 0);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(LocalDate localDate) {
		return endDayOfYear(localDate, 0);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(int years) {
		return endDayOfYear(LocalDate.now(), years);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(String date, int years) {
		return endDayOfYear(LocalDate.parse(date), years);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(Date date, int years) {
		return endDayOfYear(date2LocalDate(date), years);
	}

	/**
	 * 年 最后一天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date endDayOfYear(LocalDate localDate, int years) {
		localDate = localDate.with(TemporalAdjusters.lastDayOfYear());

		if (years > 0) {
			return Date.from(localDate.atStartOfDay(zoneId).plusYears(years)
					.plusDays(1).minusSeconds(1L).toInstant());
		}

		if (years < 0) {
			return Date.from(localDate.atStartOfDay(zoneId)
					.minusYears(Math.abs(years)).plusDays(1).minusSeconds(1L)
					.toInstant());
		}

		return Date.from(localDate.atStartOfDay(zoneId).plusDays(1)
				.minusSeconds(1L).toInstant());
	}

	/**
	 * 第N年的今天
	 * 
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfYears(int years) {
		return dayOfYears(LocalDate.now(), years);
	}

	/**
	 * 第N年的今天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfYears(String date, int years) {
		return dayOfYears(LocalDate.parse(date), years);
	}

	/**
	 * 第N年的今天
	 * 
	 * @param date
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfYears(Date date, int years) {
		return dayOfYears(date2LocalDate(date), years);
	}

	/**
	 * 第N年的今天
	 * 
	 * @param localDate
	 *            日期
	 * @param months
	 *            间隔年 +以后年 -以前年
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date dayOfYears(LocalDate localDate, int years) {
		if (years > 0) {
			return Date.from(localDate.atStartOfDay(zoneId).plusYears(years)
					.toInstant());
		}

		if (years < 0) {
			return Date.from(localDate.atStartOfDay(zoneId)
					.minusYears(Math.abs(years)).toInstant());
		}

		return new Date();
	}

	/**
	 * 间隔分钟
	 * 
	 * @param beforeDate
	 * @param afterDate
	 * @return 两个时间间隔日数
	 */
	public static int intervalMinutes(LocalDateTime beforeDate, LocalDateTime afterDate) {
		return (int)ChronoUnit.MINUTES.between(beforeDate, afterDate);
	}
	
	/**
	 * 指定时间和当前时间日间隔
	 * 
	 * @param date
	 * @return 两个时间间隔日数
	 */
	public static int intervalDays(String beforeDate) {
		return intervalDays(LocalDate.parse(beforeDate), LocalDate.now());
	}

	/**
	 * 间隔日数
	 * 
	 * @param date
	 * @param date
	 * @return 两个时间间隔日数
	 */
	public static int intervalDays(String beforeDate, String afterDate) {
		return intervalDays(LocalDate.parse(beforeDate), LocalDate.parse(afterDate));
	}

	/**
	 * 间隔月数
	 * 
	 * @param beforeDate
	 * @param afterDate
	 * @return 两个时间间隔日数
	 */
	public static int intervalDays(Date beforeDate) {
		LocalDate localDate1 = LocalDateTime.ofInstant(beforeDate.toInstant(), ZoneId.systemDefault()).toLocalDate();
		LocalDate localDate2 = LocalDate.now();
		return intervalDays(localDate1, localDate2);
	}
	
	/**
	 * 间隔月数
	 * 
	 * @param beforeDate
	 * @param afterDate
	 * @return 两个时间间隔日数
	 */
	public static int intervalDays(Date beforeDate, Date afterDate) {
		LocalDate localDate1 = LocalDateTime.ofInstant(beforeDate.toInstant(), ZoneId.systemDefault()).toLocalDate();
		LocalDate localDate2 = LocalDateTime.ofInstant(afterDate.toInstant(), ZoneId.systemDefault()).toLocalDate();
		return intervalDays(localDate1, localDate2);
	}

	/**
	 * 间隔月数
	 * 
	 * @param beforeDate
	 * @param afterDate
	 * @return 两个时间间隔日数
	 */
	public static int intervalDays(LocalDate beforeDate, LocalDate afterDate) {
		return (int)ChronoUnit.DAYS.between(beforeDate, afterDate);
	}

	/**
	 * 指定时间和当前时间月间隔
	 * 
	 * @param date
	 *            时间1
	 * @return 两个时间间隔月数
	 */
	public static int intervalMonths(String date) {
		return intervalMonths(LocalDate.parse(date), LocalDate.now());
	}

	/**
	 * 间隔月数
	 * 
	 * @param date
	 *            时间1
	 * @param date
	 *            时间2
	 * @return 两个时间间隔月数
	 */
	public static int intervalMonths(String date1, String date2) {
		return intervalMonths(LocalDate.parse(date1), LocalDate.parse(date2));
	}

	/**
	 * 间隔月数
	 * 
	 * @param date
	 *            时间1
	 * @param date
	 *            时间2
	 * @return 两个时间间隔月数
	 */
	public static int intervalMonths(Date date1, Date date2) {
		LocalDate localDate1 = LocalDateTime.ofInstant(date1.toInstant(),
				ZoneId.systemDefault()).toLocalDate();
		LocalDate localDate2 = LocalDateTime.ofInstant(date2.toInstant(),
				ZoneId.systemDefault()).toLocalDate();

		return intervalMonths(localDate1, localDate2);
	}

	/**
	 * 间隔月数
	 * 
	 * @param localDate1
	 *            时间1
	 * @param localDate2
	 *            时间2
	 * @return 两个时间间隔月数
	 */
	public static int intervalMonths(LocalDate localDate1, LocalDate localDate2) {
		Period period = Period.between(localDate1, localDate2);
		return (int) period.toTotalMonths();
	}

	/**
	 * 指定时间和当前时间年间隔
	 * 
	 * @param date
	 *            时间1
	 * @return 两个时间间隔年数
	 */
	public static int intervalYears(String date) {
		return intervalYears(LocalDate.parse(date), LocalDate.now());
	}

	/**
	 * 间隔年数
	 * 
	 * @param date
	 *            时间1
	 * @param date
	 *            时间2
	 * @return 两个时间间隔年数
	 */
	public static int intervalYears(String date1, String date2) {
		return intervalYears(LocalDate.parse(date1), LocalDate.parse(date2));
	}

	/**
	 * 间隔年数
	 * 
	 * @param date
	 *            时间1
	 * @param date
	 *            时间2
	 * @return 两个时间间隔年数
	 */
	public static int intervalYears(Date date1, Date date2) {
		LocalDate localDate1 = LocalDateTime.ofInstant(date1.toInstant(),
				ZoneId.systemDefault()).toLocalDate();
		LocalDate localDate2 = LocalDateTime.ofInstant(date2.toInstant(),
				ZoneId.systemDefault()).toLocalDate();
		return intervalYears(localDate1, localDate2);
	}

	/**
	 * 间隔年数
	 * 
	 * @param localDate1
	 *            时间1
	 * @param localDate2
	 *            时间2
	 * @return 两个时间间隔年数
	 */
	public static int intervalYears(LocalDate localDate1, LocalDate localDate2) {
		Period period = Period.between(localDate1, localDate2);
		return period.getYears();
	}

	/**
	 * Date日期转timestamp
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.sql.Timestamp}
	 */
	public static Timestamp fromDate(Date date) {
		return new Timestamp(date.getTime());
	}

	/**
	 * LocalDate日期转Date
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date localDate2Date(LocalDate localDate) {
		return Date.from(localDate.atStartOfDay(zoneId).toInstant());
	}

	/**
	 * Date日期转LocalDate
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.time.LocalDate}
	 */
	public static LocalDate date2LocalDate(Date date) {
		return LocalDateTime
				.ofInstant(date.toInstant(), ZoneId.systemDefault())
				.toLocalDate();
	}
	
	/**
	 * Date日期转LocalDateTime
	 * 
	 * @param date
	 *            日期
	 * @return 日期 {@link java.time.LocalDate}
	 */
	public static LocalDateTime date2LocalDateTime(Date date) {
		return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
	}

	/**
	 * timestamp日期转Date
	 * 
	 * @param timestamp
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static Date fromTimeStamp(Timestamp timestamp) {
		return new Date(timestamp.getTime());
	}

	/**
	 * 是否在日期之间
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isToday(Date date) {
		LocalDate localTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
		LocalDate localTime1 = LocalDate.now();
		return localTime.isEqual(localTime1);
	}
	
	/**
	 * <pre>是否在日期之间</pre>
	 * 
	 * @param localDate   日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isToday(LocalDate localTime) {
		LocalDate localTime1 = LocalDate.now();
		return localTime.isEqual(localTime1);
	}
	
	
	/**
	 * 是否昨天
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isLastday(Date date) {
		LocalDate localTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
		LocalDate localTime1 = LocalDate.now().minusDays(1);
		return localTime.isEqual(localTime1);
	}
	
	/**
	 * 判断日期是否在今日之前 截止23:59:59
	 * 
	 * @param date1 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isBeforeToday(Date date) {
		return isBefore(date, endOfDay());
	}
	
	/**
	 * 比较 日期1是否在 日期2之前
	 * 
	 * @param date1 日期
	 * @param date2 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isBefore(Date date1, Date date2) {
		LocalDateTime localTime1 = date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
		LocalDateTime localTime2 = date2.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
		return localTime1.isBefore(localTime2);
	}
	

	
	/**
	 * 判断日期是否在今日之之后 截止23:59:59
	 * 
	 * @param date 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isAfterToday(Date date) {
		if (date == null) {
			return false;
		}
		
		return isAfter(date, endOfDay());
	}
	
	/**
	 * 比较 日期1是否在 日期2之后
	 * 
	 * @param date1 日期
	 * @param date2 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isAfter(Date date1, Date date2) {
		LocalDateTime localTime1 = date1.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
		LocalDateTime localTime2 = date2.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
		return localTime1.isAfter(localTime2);
	}
	
	/**
	 * 比较 日期1是否在 日期2之后
	 * 
	 * @param date1 日期
	 * @param date2 日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isSameDay(Date date1, Date date2) {
		LocalDate localTime1 = date2LocalDate(date1);
		LocalDate localTime2 = date2LocalDate(date2);
		return localTime1.isEqual(localTime2);
	}
	
	/**
	 *  <pre>两段日期是否有重叠</pre>
	 * @param startdate1
	 * @param enddate1
	 * @param startdate2
	 * @param enddate2
	 * @return
	 */
	public static boolean isOverlap(LocalDateTime startdate1, LocalDateTime enddate1, 
			LocalDateTime startdate2, LocalDateTime enddate2) {
		long beginTime1 = Timestamp.from(startdate1.atZone(zoneId).toInstant()).getTime();
		long endTime1 = Timestamp.from(enddate1.atZone(zoneId).toInstant()).getTime();
		long beginTime2 = Timestamp.from(startdate2.atZone(zoneId).toInstant()).getTime();
		long endTime2 = Timestamp.from(enddate2.atZone(zoneId).toInstant()).getTime();
		return   ((beginTime1 >= beginTime2) && beginTime1 < endTime2)  
				||  
				((beginTime1 > beginTime2) && beginTime1 <= endTime2)  
				|| 
				((beginTime2 >= beginTime1) && beginTime2 < endTime1)  
				||  
				((beginTime2 > beginTime1) && beginTime2 <= endTime1); 
    } 

	/**
	 * 是否在日期之间
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isBetween(Date beginTime, Date endTime) {
		LocalDateTime nowTIme = LocalDateTime.now();
		return nowTIme.isAfter(date2LocalDateTime(beginTime)) && 
				nowTIme.isBefore(date2LocalDateTime(endTime));
	}
	
	/**
	 * 是否在日期之间
	 * 
	 * @param localDate
	 *            日期
	 * @return 日期 {@link java.util.Date}
	 */
	public static boolean isBetween(LocalDateTime begin, LocalDateTime end) {
		LocalDateTime nowTIme = LocalDateTime.now();
		return nowTIme.isAfter(begin) && nowTIme.isBefore(end);
	}

	/**
	 * 是否在指定时间之间
	 * 
	 * @param beginHour
	 * @param endHour
	 * @return
	 */
	public static boolean isBetween(Date date, int beginHour, int endHour) {
		return isBetween(date, beginHour, 0, 0, endHour, 0, 0);
	}

	/**
	 * 是否在指定时间之间
	 * 
	 * @param beginHour
	 * @param endHour
	 * @return
	 */
	public static boolean isBetween(Date date, int beginHour, int bMinite,
			int bsecond, int endHour, int eMinite, int esecond) {
		LocalDateTime localTime = LocalDateTime.ofInstant(date.toInstant(),
				ZoneId.systemDefault());
		LocalDateTime beginTime = LocalDateTime.of(localTime.getYear(),
				localTime.getMonth(), localTime.getDayOfMonth(), beginHour,
				bMinite, bsecond);
		LocalDateTime endTime = LocalDateTime.of(localTime.getYear(),
				localTime.getMonth(), localTime.getDayOfMonth(), endHour,
				eMinite, esecond);

		return localTime.isAfter(beginTime) && localTime.isBefore(endTime);
	}

	/**
	 * 判断是否是周末
	 * @param data
	 * @return
	 */
	public static boolean isWeek(Date data) {
		DayOfWeek df = date2LocalDate(data).getDayOfWeek();
		return df == DayOfWeek.SATURDAY || df == DayOfWeek.SUNDAY;
	}
	
	/**
	 * 判断是否是周末
	 * @param data
	 * @return
	 */
	public static boolean isDayOfWeek(Date data, DayOfWeek dayOfWeek){
		DayOfWeek df = date2LocalDate(data).getDayOfWeek();
		return df == dayOfWeek;
	}
	
	/**
	 * 判断是否是周末
	 * @param data
	 * @return
	 */
	public static boolean isDayOfWeek(Date data, List<Integer> days){
		DayOfWeek dayofWeek, preDayOfWeek;
		for (Integer day : days) {
			dayofWeek = DayOfWeek.of(day);
			preDayOfWeek = date2LocalDate(data).getDayOfWeek();
			if (dayofWeek == preDayOfWeek) {
				return true;
			}
		}
		
		return false;
	}

	public static List<Timestamp> getAllWeeks(String[] weeks) {
		List<Timestamp> timestampList = new ArrayList<>();
		
		LocalDate localDate = LocalDate.now();
		for (String week : weeks) {
			localDate = localDate.with(WeekFields.of(Locale.getDefault()).dayOfWeek(), Integer.parseInt(week));
			timestampList.add(Timestamp.from(localDate.atStartOfDay(zoneId).toInstant()));
		}
		
		return timestampList;
	}
	
	public static List<Timestamp> getDates(String beginTime, String endTime) {
		LocalDate localBeginDate = LocalDate.parse(beginTime);
		LocalDate localEndDate = LocalDate.parse(endTime);
		
		if (localBeginDate.isAfter(localEndDate)) {
			return Collections.emptyList();
		}
		
		List<Timestamp> timestampList = new ArrayList<>();
		while (!localBeginDate.isEqual(localEndDate)) {
			timestampList.add(Timestamp.from(localBeginDate.atStartOfDay(zoneId).toInstant()));
			localBeginDate = localBeginDate.plusDays(1);
		}
		timestampList.add(Timestamp.from(localEndDate.atStartOfDay(zoneId).toInstant()));
		
		
		return timestampList;
	}
	
	/**
	 * 每周的第N天
	 * @param date
	 * @return
	 */
	public static int getDayOfWeek(Date date) {
		LocalDate localDate = date2LocalDate(date);
		
	    return localDate.get(ChronoField.DAY_OF_WEEK);
	}
	
	/**
	 * 每周的第N天
	 * @param date
	 * @return
	 */
	public static int getMaxOfWeek(Date date) {
	    return DayOfWeek.SUNDAY.getValue();
	}
	
	/**
	 * 每周的第N天
	 * @param date
	 * @return
	 */
	public static int getMinOfWeek(Date date) {
	    return DayOfWeek.MONDAY.getValue();
	}
	
	/**
	 * 每月的第n天
	 * @param date
	 * @return
	 */
	public static int getDayOfMonth(Date date) {
		LocalDate localDate = date2LocalDate(date);
		
	    return localDate.get(ChronoField.DAY_OF_MONTH);
	}
	
	/**
	 * 月的最大天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getMaxOfMonth(Date date) {
		LocalDate localDate = date2LocalDate(date);
		LocalDate lastDay = localDate.with(TemporalAdjusters.lastDayOfMonth());
		
		return lastDay.get(ChronoField.DAY_OF_MONTH);
	}
	
	/**
	 * 月的最小天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getMinOfMonth(Date date) {
		return 1;
	}
	
	/**
	 * 每年的第N天
	 * @param date
	 * @return
	 */
	public static int getDayOfYear(Date date) {
		LocalDate localDate = date2LocalDate(date);
	    return localDate.get(ChronoField.DAY_OF_YEAR);
	}
	
	/**
	 * 年的最大一天
	 * @param date
	 * @return
	 */
	public static int getMaxDayOfYear(Date date) {
		LocalDate localDate = date2LocalDate(date);
		LocalDate lastDay = localDate.with(TemporalAdjusters.lastDayOfYear());
		
		return lastDay.get(ChronoField.DAY_OF_YEAR);
	}
	
	
	/**
	 * 每年的最小一天
	 * @param date
	 * @return
	 */
	public static int getMinDayOfYear(Date date) {
	    return 1;
	}
	
 
	/**
	 * 取得季度最大一天
	 * 
	 * @param date
	 * @return
	 */
	public static int getMaxOfSeason(Date date) {
		LocalDate localDate = date2LocalDate(date);
		Month[] seasonDates = getSeasonDate(date);

		int passDay = 0;
		for (Month mth : seasonDates) {
			YearMonth yearMonth = YearMonth.of(localDate.getYear(), mth);
			passDay += mth.length(yearMonth.isLeapYear());
		}
		
		return passDay;
	}
	
	/**
	 * 取得季度最小天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getMinOfSeason(Date date) {
		return 1;
	}
	
	/**
	 * 取得季度已过天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getDayOfSeason(Date date) {
		LocalDate localDate = date2LocalDate(date);
		final int passDayofMonth = localDate.get(ChronoField.DAY_OF_MONTH);
		
		Month month = localDate.getMonth();
		Month[] seasonDates = getSeasonDate(date);
		
		int passDay = passDayofMonth;
		for (Month mth : seasonDates) {
			if (mth == month) {
				break;
			} else {
				YearMonth yearMonth = YearMonth.of(localDate.getYear(), mth);
				passDay += mth.length(yearMonth.isLeapYear());
			}
		}
		
		return passDay;
	}
 
	/**
	 * 取得季度月
	 * 
	 * @param date
	 * @return
	 */
	public static Month[] getSeasonDate(Date date) {
		int nSeason = getSeason(date);
		if (nSeason == 1) {// 第一季度
			return new Month[] {Month.JANUARY, Month.FEBRUARY, Month.MARCH};
		} else if (nSeason == 2) {// 第二季度
			return new Month[] {Month.APRIL, Month.MAY, Month.JUNE};
		} else if (nSeason == 3) {// 第三季度
			return new Month[] {Month.JULY, Month.AUGUST, Month.SEPTEMBER};
		} else if (nSeason == 4) {// 第四季度
			return new Month[] {Month.OCTOBER, Month.NOVEMBER, Month.DECEMBER};
		} else {
			throw new IllegalArgumentException("unkown season" + date);
		}
	}
 
	/**
	 * 
	 * 1 第一季度 2 第二季度 3 第三季度 4 第四季度
	 * 
	 * @param date
	 * @return
	 */
	public static int getSeason(Date date) {
		final LocalDate localDate = date2LocalDate(date);
		
		final Month month = localDate.getMonth();
		if (month == Month.JANUARY ||
			month == Month.FEBRUARY ||
			month == Month.MARCH) {
			return 1;
		} else if (month == Month.APRIL ||
			month == Month.MAY ||
			month == Month.JUNE) {
			return 2;
		} else if (month == Month.JULY ||
			month == Month.AUGUST ||
			month == Month.SEPTEMBER) {
			return 3;
		} else if (month == Month.OCTOBER ||
			month == Month.NOVEMBER ||
			month == Month.DECEMBER) {
			return 4;
		} else {
			throw new IllegalArgumentException("unkown season" + date);
		}
	}
	
	/**
	 * 返回当天所属年份
	 * @return
	 */
	public static String get_yyyy() {
		return _yyyy;
	}

	/**
	 * 返回当天所属年月
	 * @return
	 */
	public static String get_yyyyMM() {
		return _yyyyMM;
	}

	/**
	 * 返回当天所属 年-月
	 * @return
	 */
	public static String get_yyyy_MM() {
		return _yyyy_MM;
	}

	/**
	 * 返回当天所属年月日
	 * @return
	 */
	public static String get_yyyyMMdd() {
		return _yyyyMMdd;
	}
	
	/**
	 * <pre>时间是否有效</pre>
	 * @param localDateTime
	 * @return
	 */
	public static boolean isValidTime(LocalDateTime localDateTime) {
		if (Objects.isNull(localDateTime)) {
			return false;
		}
		
		return localDateTime.isAfter(LocalDateTime.now());
	}
	
	public static String getOpinionNo(String id) {
		return StringUtil.join(new String[] {_yyyyMMdd, id}, "_");
	}
	
	public static String getOpinionNo(String companyNo, String type) {
		return StringUtil.join(new String[] {_yyyyMMdd, companyNo, type}, "_");
	}

	public static void nextZeroPoint() {
//		if (TimeUtil.timeSec() == _nextZeroPoint) {
//		_nextZeroPoint = TimeUtil.getNextZeroPointSecond();
		LocalDate localdate = LocalDate.now();
		_yyyy = localdate.format(DateTimeFormatter.ofPattern("yyyy"));
		_yyyyMM = localdate.format(DateTimeFormatter.ofPattern("yyyyMM"));
		_yyyy_MM = localdate.format(DateTimeFormatter.ofPattern("yyyy-MM"));
		_yyyyMMdd = localdate.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
//		}
	}

	/**
	 * 获取两个日期之间的月份
	 *
	 * @param beginDate 开始日期
	 * @param endDate   结束日期
	 * @return 两个日期之间的月份
	 * @throws ParseException
	 */
	public static Set<String> getIntervalMonth(String beginDate, String endDate) throws ParseException {
		Set<String> result = new HashSet<>();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM");
		Date begin = simpleDateFormat.parse(beginDate);
		Date end = simpleDateFormat.parse(endDate);
		while (begin.before(end)) {
			result.add(simpleDateFormat.format(begin));
			begin = addMonth(begin, 1);
		}
		result.add(simpleDateFormat.format(end));
		return result;
	}

	/**
	 * 指定的日期增加月份
	 *
	 * @param date  日期
	 * @param month 月份
	 * @return
	 */
	public static Date addMonth(Date date, int month){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MONTH, month);
		return calendar.getTime();
	}

	/**
	 * 格式化日期
	 *
	 * @param date    日期
	 * @param pattern 格式
	 * @return 格式化日期
	 * @throws ParseException
	 */
	public static Date parse(String date, String pattern) throws ParseException {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
		return simpleDateFormat.parse(date);
	}

	public static void main(String[] args) throws ParseException {
		int i = DailyUtil.intervalDays("2021-08-01", "2021-08-11");
		System.out.println(i);

		System.out.println("返回天数："+intervalDays("2021-07-01"));
	}

	private DailyUtil() {
		throw new RuntimeException();
	}

}
